We hit a wall about two years into scaling. Not a growth wall. An infrastructure wall. The kind where you suddenly realize you don't actually have one subscription system. You have five systems that are all pretending to be one.
Stripe for web. RevenueCat for mobile. The App Store doing its own thing in the corner. A homegrown entitlement service held together with webhook handlers and a prayer. And a BI team spending half their week reconstructing the customer lifecycle from events that nobody ever agreed on in the first place.
Everything technically "worked." Until one day it really didn't.
I've talked to enough people building subscription products to know this isn't a unique story. It plays out almost the same way every time.
You start simple, which is the right call. A checkout page, a payment processor, maybe a mobile SDK if you have an app. Things feel clean and manageable. Then growth happens, which is also the right call, and suddenly you're dealing with new regions, new pricing tiers, telecom partnerships, reseller channels, family plans, prepaid models, grace periods that need to behave differently depending on which market you're in, and about fifteen other things nobody planned for in year one.
Each new thing gets bolted on. And each bolt-on brings its own state, its own renewal logic, and its own definition of what an "active subscriber" actually means.
Before long, you don't have a billing problem. You have a subscription coherence problem. And those are very different things to fix.
Some of the fun symptoms that come with it:
The larger your platform gets, the more expensive the fragmentation becomes. It compounds quietly until it suddenly doesn't feel quiet at all.
Here's the thing. Stripe, Chargebee, RevenueCat, Recurly. These are genuinely good tools. I want to be clear about that because this isn't a takedown post. The problem is not the tools themselves. The problem is that the industry has slowly started treating billing infrastructure as subscription lifecycle management, and those are actually pretty different problems.
Stripe is exceptional payment infrastructure. It's probably one of the best developer-first payment systems ever built. But it wasn't designed to become your cross-channel subscription orchestration layer across app stores, telecoms, smart TVs, external storefronts, and partner ecosystems.
RevenueCat did something really elegant: it solved mobile in-app subscription normalization. If you're primarily a mobile business, it genuinely helps. But once you start expanding into web commerce, direct PSP billing, or partner distribution, you find yourself building a lot of additional infrastructure around it.
Chargebee and Recurly are solid for SaaS billing operations, invoicing, and recurring lifecycle management. But most businesses using them still end up building separate entitlement systems, storefront orchestration logic, and cross-channel consistency layers alongside them, because those tools were never meant to carry that weight.
PSPs know transactions and settlements really well. What they don't know is your entitlement logic, what "active subscriber" means when someone has an App Store subscription and a web subscription at the same time, or how to enforce a unified trial policy across iOS, Android, and your website simultaneously.
None of this is a criticism. It's just scope. Every tool in this list was built to solve a specific, well-defined problem, and they do it well. Subscription orchestration across channels, regions, and ecosystems is a broader and messier problem than any of them was designed to tackle.
The framing that finally made things click for us was this: the goal isn't "one billing system." The goal is one operational source of truth. A single consistent answer to the question "what does this customer have access to, right now, regardless of where or how they subscribed?"
That sounds simple. It really isn't, in practice.
Getting there means:
What makes this possible is a subscription orchestration layer. The idea is that it doesn't replace your PSPs or your app stores. It sits above them and coordinates everything: lifecycle state, entitlements, pricing rules, retry logic, campaign triggers, regional compliance. The billing engines keep doing what they're good at. The orchestration layer makes the whole thing coherent.
After running into these walls ourselves and spending way too long trying to patch things together, we ended up building Azotte around exactly this problem.
The core idea behind it is entitlement-first architecture. You define the value a customer receives once, and then you sell and deliver it differently across every channel, storefront, and region you operate in, without duplicating logic or maintaining parallel systems. The same bundle can be sold through your website, through the App Store, through a telecom partner, and through a reseller, and your platform still sees one normalized subscription lifecycle.
It's not a billing replacement. Think of it more as the coordination layer that finally makes your billing stack coherent and gives everyone in your business (product, finance, growth, support) the same picture of what's actually happening with your subscribers.
If you're already hitting these problems or you just want to understand the architecture before you run into the wall, it's worth a look.
The shift I keep noticing in conversations across the industry is a move away from "how do we charge for subscriptions" toward "how do we manage recurring customer access consistently across every ecosystem we operate in." Those are genuinely different questions and they need different answers.
The first question is a billing question. The second one is an orchestration question. And more subscription businesses are finding that the second question is the harder and more important one to get right.
Would love to hear where others have run into this. Was it a specific channel expansion that broke things? A migration that took way longer than it should have? A market you couldn't enter cleanly because your subscription model wasn't portable enough? Drop it in the comments, genuinely curious.